﻿#include <iostream>
using namespace std;
#include <vector>
#include<algorithm>
#include<string>
#include<math.h>

//class People
//{
//public:
//	People(int n = 0)
//		:num(n)
//	{
//		cout << "People()" << endl;
//	}
//
//	~People()
//	{
//		cout << "~People()" << endl;
//	}
//
//	People& operator=(const People& p)
//	{
//		num = p.num;
//	}
//
//	void print()
//	{
//		cout << num << endl;
//	}
//
//protected:
//	int num;
//};
//
//class Teacher : public People
//{
//public:
//	Teacher()
//		:People(0)
//		,num(1)
//	{
//		cout << "Teacher()" << endl;
//	}
//
//	~Teacher()
//	{
//		cout << "~Teacher()" << endl;
//	}
//
//	void print()
//	{
//		cout << num << endl;
//	}
//
//protected:
//	int num;
//};
//
//class Student : private People
//{
//public:
//	Student()
//		:People(0)
//		, num(2)
//	{
//		cout << "Student()" << endl;
//	}
//
//	~Student()
//	{
//		cout << "~Student()" << endl;
//	}
//
//	void print()
//	{
//		People::num = 10;
//		cout << num << endl;
//	}
//
//protected:
//	int num;
//};
//
//int main()
//{
//	//Student s;
//	//People p = s; //子类成员赋值给父类
//	//People& pref = s; //父类引用子类
//	//People* ptrp = &s; //父类指针指向子类
//	//(*ptrp).print(); //表现出父类的特性(剪切子类表现出父类)
//
//	return 0;
//}


//class A
//{
//public:
//	void speak()
//	{
//		cout << "A" << endl;
//	}
//};
//
//class B :public A
//{
//public:
//	void speak(int n)
//	{
//		A::speak();
//		cout << "B" << endl;
//	}
//	//两个speak并不构成重载，而是构成隐藏
//};
//
//int main()
//{
//	A a;
//	a.speak();
//	B b;
//	b.speak(1);
//	return 0;
//}




//class A
//{
//public:
//	A(int n = 0)
//		:_num(n)
//	{
//		cout << "A(int n = 0)" << endl;
//	}
//
//	A(const A& a)
//		:_num(a._num)
//	{
//		cout << "A(const A& a)" << endl;
//	}
//
//	A& operator=(const A& a)
//	{
//		if (&a != this)
//		{
//			_num = a._num;
//			cout << "operator=(const A& a)" << endl;
//		}
//		return *this;
//	}
//
//	~A()
//	{
//		cout << "~A()" << endl;
//	}
//
//protected:
//	int _num;
//};
//
//class B : public A
//{
//public:
//	B(int n = 0)
//		:A(n)
//		,_sum(n)
//	{
//		cout << "B(int n = 0)" << endl;
//	}
//
//	B(const B& b)
//		:A(b)//通过切片构造父类然后拷贝构造自己
//		,_sum(b._sum)
//	{
//		cout << "B(const B& b)" << endl;
//	}
//
//	B& operator=(const B& b)
//	{
//		if (&b != this)
//		{
//			A::operator=(b);
//			_sum = b._sum;
//			cout << "operator=(const B& b)" << endl;
//		}
//		return *this;
//	}
//
//	~B()
//	{
//		cout << "~B()" << endl;
//	}
//
//protected:
//	int _sum;
//};
//
//int main()
//{
//	B b(1); //子类构造
//	B b1 = b; //拷贝构造
//	B b3; 
//	b3 = b; //赋值重载
//	return 0;
//}

class A
{
public:
	int pub;
protected:
	int _Anum;
};

class B : virtual public A //虚继承解决菱形继承问题！
{
protected:
	int _Bnum;
};

class C : virtual public A
{
protected:
	int _Cnum;
};

class D : public B, public C
{
protected:
	int _Dnum;
};

int main()
{
	D d;
	//d.B::pub = 0; //菱形继承导致数据冗余和二义性，信息不唯一不明确
	//d.C::pub = 0; 
	d.pub = 0;
	return 0;
}